为什么你的 Racket 代码性能不佳？可能是数据结构选错了 🚀

#Innolight #Lisp #Racket

💡 在 Racket 中，选择合适的数据结构能显著提升代码性能！列表、向量和集合各有特点，错误的选择可能导致程序变慢 10 倍以上。本文将带你掌握这三种核心数据结构的正确使用场景和优化技巧。✨

🛠 列表 (List) - 函数式编程的基石

📌 列表是 Racket 中最基础的数据结构，采用链表实现，支持异构元素，是函数式编程的核心。

🔹 基本操作

;; 创建列表
(list 1 2 3 4)           ; '(1 2 3 4)
'(1 2 3 4)               ; 同上，引用语法
(cons 1 '(2 3 4))        ; '(1 2 3 4)

;; 访问元素
(first '(1 2 3))         ; 1
(rest '(1 2 3))          ; '(2 3)
(second '(1 2 3))        ; 2
(list-ref '(1 2 3) 0)    ; 1，按索引访问

;; 判断
(empty? '())             ; #t
(list? '(1 2 3))         ; #t

🔹 常用函数

(length '(1 2 3))        ; 3
(append '(1 2) '(3 4))   ; '(1 2 3 4)
(reverse '(1 2 3))       ; '(3 2 1)
(member 2 '(1 2 3))      ; '(2 3)
(map add1 '(1 2 3))      ; '(2 3 4)
(filter even? '(1 2 3 4)); '(2 4)

⚠️ 性能特点：

• 头部插入 O(1)，随机访问 O(n)
• 适合递归处理和频繁的头部操作
• 尾部操作效率低，需谨慎使用

⚡ 向量 (Vector) - 高性能随机访问

💡 向量提供类似数组的随机访问能力，元素可变，是性能敏感场景的首选。

🔧 基本操作

;; 创建向量
(vector 1 2 3 4)         ; #(1 2 3 4)
(make-vector 4 0)        ; #(0 0 0 0)
(build-vector 4 add1)    ; #(1 2 3 4)

;; 访问和修改
(vector-ref #(1 2 3) 0)  ; 1
(vector-length #(1 2 3)) ; 3

;; 修改向量（需要可变向量）
(define v (vector 1 2 3))    ; 创建可变向量
(vector-set! v 0 9)          ; 修改第0个元素为9
v                            ; #(9 2 3)

⚠️ 可变性说明

;; 字面量语法创建不可变向量
#(1 2 3)                 ; 不可变
(vector 1 2 3)           ; 可变
(make-vector 4 0)        ; 可变

;; 转换
(vector->immutable-vector (vector 1 2 3))  ; 转为不可变
(vector-copy #(1 2 3))   ; 创建可变副本

📌 性能优势：

• 随机访问 O(1)，适合需要索引访问的场景
• 内存连续，缓存友好
• 修改操作需注意可变性限制

🔄 集合 (Set) - 高效去重与集合运算

✨ 集合确保元素唯一性，支持快速成员检测和数学集合运算。

✅ 基本操作

;; 创建集合
(set 1 2 3 2)            ; (set 1 2 3)
(list->set '(1 2 3 2))   ; (set 1 2 3)
(seteq 'a 'b 'c)         ; 使用eq?比较的集合

;; 基本操作
(set-member? (set 1 2 3) 2)  ; #t
(set-add (set 1 2) 3)        ; (set 1 2 3)
(set-remove (set 1 2 3) 2)   ; (set 1 3)
(set-count (set 1 2 3))      ; 3

➕ 集合运算

(set-union (set 1 2) (set 2 3))      ; (set 1 2 3)
(set-intersect (set 1 2 3) (set 2 3 4))  ; (set 2 3)
(set-subtract (set 1 2 3) (set 2))   ; (set 1 3)
(set-symmetric-difference (set 1 2) (set 2 3))  ; (set 1 3)

💡 适用场景：

• 元素去重需求
• 频繁成员检测
• 数学集合运算

📊 数据结构选择指南

🚀 实用示例

🔧 数据处理流水线

;; 列表处理：筛选偶数并平方
(map (lambda (x) (* x x))
     (filter even? '(1 2 3 4 5 6)))  ; '(4 16 36)

;; 向量批处理
(define nums #(1 2 3 4 5))
(vector-map (lambda (x) (if (even? x) (* x x) x)) nums)  ; #(1 4 3 16 5)

;; 集合去重统计
(set-count (list->set '(1 2 2 3 3 3 4)))  ; 4

💭 总结：在 Racket 中，选择正确的数据结构是优化性能的关键！列表适合函数式处理，向量适合随机访问，集合则专精于去重和集合运算。根据你的具体需求做出明智选择吧！✨